package org.codefilarete.stalactite.engine.runtime;

import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import javax.annotation.Nullable;

import org.codefilarete.reflection.AccessorChain;
import org.codefilarete.reflection.Accessors;
import org.codefilarete.reflection.PropertyAccessPoint;
import org.codefilarete.reflection.SerializablePropertyAccessor;
import org.codefilarete.reflection.SerializablePropertyMutator;
import org.codefilarete.reflection.ValueAccessPoint;
import org.codefilarete.stalactite.engine.EntityCriteria;
import org.codefilarete.stalactite.engine.EntityPersister;
import org.codefilarete.stalactite.engine.ExecutableQuery;
import org.codefilarete.stalactite.engine.runtime.load.EntityJoinTree;
import org.codefilarete.stalactite.query.RelationalEntityCriteria;
import org.codefilarete.stalactite.query.model.ConditionalOperator;
import org.codefilarete.stalactite.sql.ddl.structure.Column;
import org.codefilarete.stalactite.sql.ddl.structure.Key;
import org.codefilarete.stalactite.sql.ddl.structure.Table;
import org.codefilarete.stalactite.sql.result.BeanRelationFixer;
import org.codefilarete.stalactite.sql.result.ColumnedRow;
import org.codefilarete.tool.collection.Arrays;

/**
 * Contract to allow joining a persister with another for entities with relation.
 * 
 * @author Guillaume Mary
 */
public interface RelationalEntityPersister<C, I> extends EntityPersister<C, I> {
	
	/**
	 * Called to join this instance with given persister. For this method, current instance is considered as the "right part" of the relation.
	 * Made as such because polymorphic cases (which are instance of this interface) are the only one who knows how to join themselves with another persister.
	 *
	 * @param <SRC>             source entity type
	 * @param <T1>              left table type
	 * @param <T2>              right table type
	 * @param rootJoinName
	 * @param sourcePersister   source that needs this instance joins
	 * @param propertyAccessor  accessor to the property of this persister's entity from the source entity type
	 * @param leftColumn        left part of the join, expected to be one of source table
	 * @param rightColumn       right part of the join, expected to be one of current instance table
	 * @param rightTableAlias   optional alias for right table, if null table name will be used
	 * @param beanRelationFixer setter that fix relation of this instance onto source persister instance
	 * @param optional          true for optional relation, makes an outer join, else should create a inner join
	 * @param loadSeparately    indicator to make the target entities loaded in a separate query
	 * @return the created join name, then it could be found in sourcePersister#getEntityJoinTree
	 */
	<SRC, T1 extends Table<T1>, T2 extends Table<T2>, SRCID, JOINID> String joinAsOne(String rootJoinName,
																					  RelationalEntityPersister<SRC, SRCID> sourcePersister,
	                                                                                  PropertyAccessPoint<SRC, C> propertyAccessor,
	                                                                                  Key<T1, JOINID> leftColumn,
	                                                                                  Key<T2, JOINID> rightColumn,
	                                                                                  @Nullable String rightTableAlias,
	                                                                                  BeanRelationFixer<SRC, C> beanRelationFixer,
	                                                                                  boolean optional,
	                                                                                  boolean loadSeparately);
	
	/**
	 * Called to join this instance with given persister. For this method, current instance is considered as the "right part" of the relation.
	 * Made as such because polymorphic cases (which are instance of this interface) are the only one who knows how to join themselves with another persister.
	 *
	 * @param <SRC> source entity type
	 * @param <T1> left table type
	 * @param <T2> right table type
	 * @param sourcePersister source that needs this instance joins
	 * @param propertyAccessor accessor to the property of this persister's entity from the source entity type
	 * @param leftColumn left part of the join, expected to be one of source table
	 * @param rightColumn right part of the join, expected to be one of current instance table
	 * @param beanRelationFixer setter that fix relation of this instance onto source persister instance, expected to manage collection instantiation
	 * @param duplicateIdentifierProvider a function that computes the relation identifier
	 * @param joinName parent join node name on which join must be added,
	 * not always {@link EntityJoinTree#ROOT_JOIN_NAME} in particular in one-to-many with association table
	 * @param optional true for optional relation, makes an outer join, else should create a inner join
	 * @param loadSeparately indicator to make the target entities loaded in a separate query
	 */
	default <SRC, T1 extends Table<T1>, T2 extends Table<T2>, SRCID, JOINID, S> String joinAsMany(String joinName,
	                                                                                              RelationalEntityPersister<SRC, SRCID> sourcePersister,
	                                                                                              PropertyAccessPoint<SRC, S> propertyAccessor,
	                                                                                              Key<T1, JOINID> leftColumn,
	                                                                                              Key<T2, JOINID> rightColumn,
	                                                                                              BeanRelationFixer<SRC, C> beanRelationFixer,
	                                                                                              @Nullable Function<ColumnedRow, Object> duplicateIdentifierProvider,
	                                                                                              boolean optional,
	                                                                                              boolean loadSeparately) {
		return joinAsMany(joinName, sourcePersister, propertyAccessor, leftColumn, rightColumn, beanRelationFixer,
				duplicateIdentifierProvider, Collections.emptySet(), optional, loadSeparately);
	}
	
	/**
	 * Called to join this instance with given persister. For this method, current instance is considered as the "right part" of the relation.
	 * Made as such because polymorphic cases (which are instance of this interface) are the only one who knows how to join themselves with another persister.
	 *
	 * @param <SRC> source entity type
	 * @param <T1> left table type
	 * @param <T2> right table type
	 * @param sourcePersister source that needs this instance joins
	 * @param propertyAccessor accessor to the property of this persister's entity from the source entity type
	 * @param leftColumn left part of the join, expected to be one of source table
	 * @param rightColumn right part of the join, expected to be one of current instance table
	 * @param beanRelationFixer setter that fix relation of this instance onto source persister instance, expected to manage collection instantiation
	 * @param duplicateIdentifierProvider a function that computes the relation identifier
	 * @param joinName parent join node name on which join must be added,
	 * not always {@link EntityJoinTree#ROOT_JOIN_NAME} in particular in one-to-many with association table
	 * @param selectableColumns columns to be added to SQL select clause
	 * @param optional true for optional relation, makes an outer join, else should create a inner join
	 * @param loadSeparately indicator to make the target entities loaded in a separate query
	 */
	<SRC, T1 extends Table<T1>, T2 extends Table<T2>, SRCID, JOINID, S> String joinAsMany(String joinName,
	                                                                                      RelationalEntityPersister<SRC, SRCID> sourcePersister,
	                                                                                      PropertyAccessPoint<SRC, S> propertyAccessor,
	                                                                                      Key<T1, JOINID> leftColumn,
	                                                                                      Key<T2, JOINID> rightColumn,
	                                                                                      BeanRelationFixer<SRC, C> beanRelationFixer,
	                                                                                      @Nullable Function<ColumnedRow, Object> duplicateIdentifierProvider,
	                                                                                      Set<? extends Column<T2, ?>> selectableColumns,
	                                                                                      boolean optional,
	                                                                                      boolean loadSeparately);
	
	EntityJoinTree<C, I> getEntityJoinTree();
	
	/**
	 * Copies current instance joins root to given select
	 * 
	 * @param entityJoinTree target of the copy
	 * @param joinName name of target select join on which joins of this instance must be copied
	 * @param <E> target select entity type
	 * @param <ID> identifier type
	 */
	<E, ID> void copyRootJoinsTo(EntityJoinTree<E, ID> entityJoinTree, String joinName);
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	default <O> ExecutableEntityQueryCriteria<C, ?> selectWhere(SerializablePropertyAccessor<C, O> getter, ConditionalOperator<O, ?> operator) {
		return selectWhere(AccessorChain.fromMethodReference(getter), operator);
	}
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	default <O> ExecutableEntityQueryCriteria<C, ?> selectWhere(SerializablePropertyMutator<C, O> setter, ConditionalOperator<O, ?> operator) {
		return selectWhere(Arrays.asList(Accessors.mutatorByMethodReference(setter)), operator);
	}
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	default <O, A> ExecutableEntityQueryCriteria<C, ?> selectWhere(SerializablePropertyAccessor<C, A> getter1, SerializablePropertyAccessor<A, O> getter2, ConditionalOperator<O, ?> operator) {
		return selectWhere(AccessorChain.fromMethodReferences(getter1, getter2), operator);
	}
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	default <O> ExecutableEntityQueryCriteria<C, ?> selectWhere(List<? extends ValueAccessPoint<?>> accessorChain, ConditionalOperator<O, ?> operator) {
		return selectWhere().and(accessorChain, operator);
	}
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	default <O> ExecutableEntityQueryCriteria<C, ?> selectWhere(AccessorChain<C, ?> accessorChain, ConditionalOperator<O, ?> operator) {
		return selectWhere().and(accessorChain, operator);
	}
	
	/**
	 * Overridden for a more accurate return type.
	 * {@inheritDoc}
	 */
	ExecutableEntityQueryCriteria<C, ?> selectWhere();
	
	/**
	 * Mashup between {@link EntityCriteria} and {@link ExecutableQuery} to make an {@link EntityCriteria} executable
	 * @param <C> type of object returned by query execution
	 */
	interface ExecutableEntityQueryCriteria<C, SELF extends ExecutableEntityQueryCriteria<C, SELF>>
			extends ExecutableEntityQuery<C, SELF>, RelationalEntityCriteria<C, SELF>, EntityCriteria.OrderByChain<C, SELF> {
		
	}
}
